LukasMeine / vigilance

;(function() {

  /** Used as a safe reference for `undefined` in pre-ES5 environments. */

  var undefined;

  /** Used as the semantic version number. */

  var VERSION = '3.10.1';

  /** Used to compose bitmasks for wrapper metadata. */

  var BIND_FLAG = 1,

      BIND_KEY_FLAG = 2,

      CURRY_BOUND_FLAG = 4,

      CURRY_FLAG = 8,

      CURRY_RIGHT_FLAG = 16,

      PARTIAL_FLAG = 32,

      PARTIAL_RIGHT_FLAG = 64,

      ARY_FLAG = 128,

      REARG_FLAG = 256;

  /** Used as default options for `_.trunc`. */

  var DEFAULT_TRUNC_LENGTH = 30,

      DEFAULT_TRUNC_OMISSION = '...';

  /** Used to detect when a function becomes hot. */

  var HOT_COUNT = 150,

      HOT_SPAN = 16;

  /** Used as the size to enable large array optimizations. */

  var LARGE_ARRAY_SIZE = 200;

  /** Used to indicate the type of lazy iteratees. */

  var LAZY_FILTER_FLAG = 1,

      LAZY_MAP_FLAG = 2;

  /** Used as the `TypeError` message for "Functions" methods. */

  var FUNC_ERROR_TEXT = 'Expected a function';

  /** Used as the internal argument placeholder. */

  var PLACEHOLDER = '__lodash_placeholder__';

  /** `Object#toString` result references. */

  var argsTag = '[object Arguments]',

      arrayTag = '[object Array]',

      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

      // Patched from https://github.com/lodash/lodash/blob/95bc54a3ddc7a25f5e134f5b376a0d1d96118f49/lodash.js#L86-L108

      asyncTag = '[object AsyncFunction]',

      genTag = '[object GeneratorFunction]',

      proxyTag = '[object Proxy]',

      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

      boolTag = '[object Boolean]',

      dateTag = '[object Date]',

      errorTag = '[object Error]',

      funcTag = '[object Function]',

      mapTag = '[object Map]',

      numberTag = '[object Number]',

      objectTag = '[object Object]',

      regexpTag = '[object RegExp]',

      setTag = '[object Set]',

      stringTag = '[object String]',

      weakMapTag = '[object WeakMap]';

  var arrayBufferTag = '[object ArrayBuffer]',

      float32Tag = '[object Float32Array]',

      float64Tag = '[object Float64Array]',

      int8Tag = '[object Int8Array]',

      int16Tag = '[object Int16Array]',

      int32Tag = '[object Int32Array]',

      uint8Tag = '[object Uint8Array]',

      uint8ClampedTag = '[object Uint8ClampedArray]',

      uint16Tag = '[object Uint16Array]',

      uint32Tag = '[object Uint32Array]';

  /** Used to match empty string literals in compiled template source. */

  var reEmptyStringLeading = /\b__p \+= '';/g,

      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,

      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

  /** Used to match HTML entities and HTML characters. */

  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39|#96);/g,

      reUnescapedHtml = /[&<>"'`]/g,

      reHasEscapedHtml = RegExp(reEscapedHtml.source),

      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

  /** Used to match template delimiters. */

  var reEscape = /<%-([\s\S]+?)%>/g,

      reEvaluate = /<%([\s\S]+?)%>/g,

      reInterpolate = /<%=([\s\S]+?)%>/g;

  /** Used to match property names within property paths. */

  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,

      reIsPlainProp = /^\w*$/,

      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;

  /**

   * Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns)

   * and those outlined by [`EscapeRegExpPattern`](http://ecma-international.org/ecma-262/6.0/#sec-escaperegexppattern).

   */

  var reRegExpChars = /^[:!,]|[\\^$.*+?()[\]{}|\/]|(^[0-9a-fA-Fnrtuvx])|([\n\r\u2028\u2029])/g,

      reHasRegExpChars = RegExp(reRegExpChars.source);

  /** Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). */

  var reComboMark = /[\u0300-\u036f\ufe20-\ufe23]/g;

  /** Used to match backslashes in property paths. */

  var reEscapeChar = /\\(\\)?/g;

  /** Used to match [ES template delimiters](http://ecma-international.org/ecma-262/6.0/#sec-template-literal-lexical-components). */

  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

  /** Used to match `RegExp` flags from their coerced string values. */

  var reFlags = /\w*$/;

  /** Used to detect hexadecimal string values. */

  var reHasHexPrefix = /^0[xX]/;

  /** Used to detect host constructors (Safari > 5). */

  var reIsHostCtor = /^\[object .+?Constructor\]$/;

  /** Used to detect unsigned integer values. */

  var reIsUint = /^\d+$/;

  /** Used to match latin-1 supplementary letters (excluding mathematical operators). */

  var reLatin1 = /[\xc0-\xd6\xd8-\xde\xdf-\xf6\xf8-\xff]/g;

  /** Used to ensure capturing order of template delimiters. */

  var reNoMatch = /($^)/;

  /** Used to match unescaped characters in compiled string literals. */

  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

  /** Used to match words to create compound words. */

  var reWords = (function() {

    var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]',

        lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+';

    return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g');

  }());

  /** Used to assign default `context` object properties. */

  var contextProps = [

    'Array', 'ArrayBuffer', 'Date', 'Error', 'Float32Array', 'Float64Array',

    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Math', 'Number',

    'Object', 'RegExp', 'Set', 'String', '_', 'clearTimeout', 'isFinite',

    'parseFloat', 'parseInt', 'setTimeout', 'TypeError', 'Uint8Array',

    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap'

  ];

  /** Used to fix the JScript `[[DontEnum]]` bug. */

  var shadowProps = [

    'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',

    'toLocaleString', 'toString', 'valueOf'

  ];

  /** Used to make template sourceURLs easier to identify. */

  var templateCounter = -1;

  /** Used to identify `toStringTag` values of typed arrays. */

  var typedArrayTags = {};

  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

  typedArrayTags[uint32Tag] = true;

  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

  typedArrayTags[dateTag] = typedArrayTags[errorTag] =

  typedArrayTags[funcTag] = typedArrayTags[mapTag] =

  typedArrayTags[numberTag] = typedArrayTags[objectTag] =

  typedArrayTags[regexpTag] = typedArrayTags[setTag] =

  typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

  /** Used to identify `toStringTag` values supported by `_.clone`. */

  var cloneableTags = {};

  cloneableTags[argsTag] = cloneableTags[arrayTag] =

  cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =

  cloneableTags[dateTag] = cloneableTags[float32Tag] =

  cloneableTags[float64Tag] = cloneableTags[int8Tag] =

  cloneableTags[int16Tag] = cloneableTags[int32Tag] =

  cloneableTags[numberTag] = cloneableTags[objectTag] =

  cloneableTags[regexpTag] = cloneableTags[stringTag] =

  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

  cloneableTags[errorTag] = cloneableTags[funcTag] =

  cloneableTags[mapTag] = cloneableTags[setTag] =

  cloneableTags[weakMapTag] = false;

  /** Used to map latin-1 supplementary letters to basic latin letters. */

  var deburredLetters = {

    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

    '\xc7': 'C',  '\xe7': 'c',

    '\xd0': 'D',  '\xf0': 'd',

    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

    '\xcC': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

    '\xeC': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',

    '\xd1': 'N',  '\xf1': 'n',

    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',

    '\xc6': 'Ae', '\xe6': 'ae',

    '\xde': 'Th', '\xfe': 'th',

    '\xdf': 'ss'

  };

  /** Used to map characters to HTML entities. */

  var htmlEscapes = {

    '&': '&',

    '<': '&lt;',

    '>': '>',

    '"': '"',

    "'": ''',

    '`': '`'

  };

  /** Used to map HTML entities to characters. */

  var htmlUnescapes = {

    '&': '&',

    '&lt;': '<',

    '>': '>',

    '"': '"',

    ''': "'",

    '`': '`'

  };

  /** Used to determine if values are of the language type `Object`. */

  var objectTypes = {

    'function': true,

    'object': true

  };

  /** Used to escape characters for inclusion in compiled regexes. */

  var regexpEscapes = {

    '0': 'x30', '1': 'x31', '2': 'x32', '3': 'x33', '4': 'x34',

    '5': 'x35', '6': 'x36', '7': 'x37', '8': 'x38', '9': 'x39',

    'A': 'x41', 'B': 'x42', 'C': 'x43', 'D': 'x44', 'E': 'x45', 'F': 'x46',

    'a': 'x61', 'b': 'x62', 'c': 'x63', 'd': 'x64', 'e': 'x65', 'f': 'x66',

    'n': 'x6e', 'r': 'x72', 't': 'x74', 'u': 'x75', 'v': 'x76', 'x': 'x78'

  };

  /** Used to escape characters for inclusion in compiled string literals. */

  var stringEscapes = {

    '\\': '\\',

    "'": "'",

    '\n': 'n',

    '\r': 'r',

    '\u2028': 'u2028',

    '\u2029': 'u2029'

  };

  /** Detect free variable `exports`. */

  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */

  var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;

  /** Detect free variable `global` from Node.js. */

  var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;

  /** Detect free variable `self`. */

  /** Detect free variable `window`. */

  var freeWindow = objectTypes[typeof window] && window && window.Object && window;

  /** Detect the popular CommonJS extension `module.exports`. */

  var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;

  /**

   * Used as a reference to the global object.

   *

   * The `this` value is used if it's the global object to avoid Greasemonkey's

   * restricted `window` object, otherwise the `window` object is used.

   */

  var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;

  /*--------------------------------------------------------------------------*/

  /**

   * The base implementation of `compareAscending` which compares values and

   * sorts them in ascending order without guaranteeing a stable sort.

   *

   * @private

   * @param {*} value The value to compare.

   * @param {*} other The other value to compare.

   * @returns {number} Returns the sort order indicator for `value`.

   */

  function baseCompareAscending(value, other) {

    if (value !== other) {

      var valIsNull = value === null,

          valIsReflexive = value === value;

      var othIsNull = other === null,

          othIsUndef = other === undefined,

          othIsReflexive = other === other;

      if ((value > other && !othIsNull) || !valIsReflexive ||

          (valIsNull && !othIsUndef && othIsReflexive) ||

          (valIsUndef && othIsReflexive)) {

        return 1;

      }

      if ((value < other && !valIsNull) || !othIsReflexive ||

          (othIsNull && !valIsUndef && valIsReflexive) ||

          (othIsUndef && valIsReflexive)) {

        return -1;

      }

    }

    return 0;

  }

  /**

   * The base implementation of `_.findIndex` and `_.findLastIndex` without

   * support for callback shorthands and `this` binding.

   *

   * @private

   * @param {Array} array The array to search.

   * @param {Function} predicate The function invoked per iteration.

   * @param {boolean} [fromRight] Specify iterating from right to left.

   * @returns {number} Returns the index of the matched value, else `-1`.

   */

  function baseFindIndex(array, predicate, fromRight) {

    var length = array.length,

        index = fromRight ? length : -1;

    while ((fromRight ? index-- : ++index < length)) {

      if (predicate(array[index], index, array)) {

        return index;

      }

    }

    return -1;

  }

  /**

   * The base implementation of `_.indexOf` without support for binary searches.

   *

   * @private

   * @param {Array} array The array to search.

   * @param {*} value The value to search for.

   * @param {number} fromIndex The index to search from.

   * @returns {number} Returns the index of the matched value, else `-1`.

   */

  function baseIndexOf(array, value, fromIndex) {

    if (value !== value) {

      return indexOfNaN(array, fromIndex);

    }

    var index = fromIndex - 1,

        length = array.length;

    while (++index < length) {

      if (array[index] === value) {

        return index;

      }

    }

    return -1;

  }

  /**

   * The base implementation of `_.isFunction` without support for environments

   * with incorrect `typeof` results.

   *

   * @private

   * @param {*} value The value to check.

   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.

   */

  function baseIsFunction(value) {

    // Avoid a Chakra JIT bug in compatibility modes of IE 11.

    // See https://github.com/jashkenas/underscore/issues/1621 for more details.

    return typeof value == 'function' || false;

  }

  /**

   * Converts `value` to a string if it's not one. An empty string is returned

   * for `null` or `undefined` values.

   *

   * @private

   * @param {*} value The value to process.

   * @returns {string} Returns the string.

   */

  function baseToString(value) {

  }

  /**

   * Used by `_.trim` and `_.trimLeft` to get the index of the first character

   * of `string` that is not found in `chars`.

   *

   * @private

   * @param {string} string The string to inspect.

   * @param {string} chars The characters to find.

   * @returns {number} Returns the index of the first character not found in `chars`.

   */

  function charsLeftIndex(string, chars) {

    var index = -1,

        length = string.length;

    return index;

  }

  /**

   * Used by `_.trim` and `_.trimRight` to get the index of the last character

   * of `string` that is not found in `chars`.

   *

   * @private

   * @param {string} string The string to inspect.

   * @param {string} chars The characters to find.

   * @returns {number} Returns the index of the last character not found in `chars`.

   */

  function charsRightIndex(string, chars) {

    var index = string.length;

    return index;

  }

  /**

   * Used by `_.sortBy` to compare transformed elements of a collection and stable

   * sort them in ascending order.

   *

   * @private

   * @param {Object} object The object to compare.

   * @param {Object} other The other object to compare.

   * @returns {number} Returns the sort order indicator for `object`.

   */

  function compareAscending(object, other) {

    return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);

  }

  /**

   * Used by `_.sortByOrder` to compare multiple properties of a value to another

   * and stable sort them.

   *

   * If `orders` is unspecified, all valuess are sorted in ascending order. Otherwise,

   * a value is sorted in ascending order if its corresponding order is "asc", and

   * descending if "desc".

   *

   * @private

   * @param {Object} object The object to compare.

   * @param {Object} other The other object to compare.

   * @param {boolean[]} orders The order to sort by for each property.

   * @returns {number} Returns the sort order indicator for `object`.

   */

  function compareMultiple(object, other, orders) {

    var index = -1,

        objCriteria = object.criteria,

        othCriteria = other.criteria,

        length = objCriteria.length,

        ordersLength = orders.length;

    while (++index < length) {

      var result = baseCompareAscending(objCriteria[index], othCriteria[index]);

      if (result) {

        if (index >= ordersLength) {

          return result;

        }

        var order = orders[index];

        return result * ((order === 'asc' || order === true) ? 1 : -1);

      }

    }

    // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications

    // that causes it, under certain circumstances, to provide the same value for

    // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247

    // for more details.

    //

    // This also ensures a stable sort in V8 and other engines.

    // See https://code.google.com/p/v8/issues/detail?id=90 for more details.

    return object.index - other.index;

  }

  /**

   * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters.

   *

   * @private

   * @param {string} letter The matched letter to deburr.

   * @returns {string} Returns the deburred letter.

   */

  function deburrLetter(letter) {

    return deburredLetters[letter];

  }

  /**

   * Used by `_.escape` to convert characters to HTML entities.

   *

   * @private

   * @param {string} chr The matched character to escape.

   * @returns {string} Returns the escaped character.

   */

  function escapeHtmlChar(chr) {

    return htmlEscapes[chr];

  }

  /**

   * Used by `_.escapeRegExp` to escape characters for inclusion in compiled regexes.

   *

   * @private

   * @param {string} chr The matched character to escape.

   * @param {string} leadingChar The capture group for a leading character.

   * @param {string} whitespaceChar The capture group for a whitespace character.

   * @returns {string} Returns the escaped character.

   */

  function escapeRegExpChar(chr, leadingChar, whitespaceChar) {

    if (leadingChar) {

      chr = regexpEscapes[chr];

    } else if (whitespaceChar) {

      chr = stringEscapes[chr];

    }

    return '\\' + chr;

  }

  /**

   * Used by `_.template` to escape characters for inclusion in compiled string literals.

   *

   * @private

   * @param {string} chr The matched character to escape.

   * @returns {string} Returns the escaped character.

   */

  function escapeStringChar(chr) {

    return '\\' + stringEscapes[chr];

  }

  /**

   * Gets the index at which the first occurrence of `NaN` is found in `array`.

   *

   * @private

   * @param {Array} array The array to search.

   * @param {number} fromIndex The index to search from.

   * @param {boolean} [fromRight] Specify iterating from right to left.

   * @returns {number} Returns the index of the matched `NaN`, else `-1`.

   */

  function indexOfNaN(array, fromIndex, fromRight) {

    var length = array.length,

        index = fromIndex + (fromRight ? 0 : -1);

    while ((fromRight ? index-- : ++index < length)) {

      var other = array[index];

      if (other !== other) {

        return index;

      }

    }

    return -1;

  }

  /**

   * Checks if `value` is a host object in IE < 9.

   *

   * @private

   * @param {*} value The value to check.

   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.

   */

  var isHostObject = (function() {

    try {

      Object({ 'toString': 0 } + '');

    } catch(e) {

      return function() { return false; };

    }

    return function(value) {

      // IE < 9 presents many host objects as `Object` objects that can coerce

      // to strings despite having improperly defined `toString` methods.

      return typeof value.toString != 'function' && typeof (value + '') == 'string';

    };

  }());

  /**

   * Checks if `value` is object-like.

   *

   * @private

   * @param {*} value The value to check.

   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.

   */

  function isObjectLike(value) {

    return !!value && typeof value == 'object';

  }

  /**

   * Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a

   * character code is whitespace.

   *

   * @private

   * @param {number} charCode The character code to inspect.

   * @returns {boolean} Returns `true` if `charCode` is whitespace, else `false`.

   */

  function isSpace(charCode) {

    return ((charCode <= 160 && (charCode >= 9 && charCode <= 13) || charCode == 32 || charCode == 160) || charCode == 5760 || charCode == 6158 ||

      (charCode >= 8192 && (charCode <= 8202 || charCode == 8232 || charCode == 8233 || charCode == 8239 || charCode == 8287 || charCode == 12288 || charCode == 65279)));

  }

  /**

   * Replaces all `placeholder` elements in `array` with an internal placeholder

   * and returns an array of their indexes.

   *

   * @private

   * @param {Array} array The array to modify.

   * @param {*} placeholder The placeholder to replace.

   * @returns {Array} Returns the new array of placeholder indexes.

   */

  function replaceHolders(array, placeholder) {

    var index = -1,

        length = array.length,

        resIndex = -1,

        result = [];

    while (++index < length) {

      if (array[index] === placeholder) {

        array[index] = PLACEHOLDER;

        result[++resIndex] = index;

      }

    }

    return result;

  }

  /**

   * An implementation of `_.uniq` optimized for sorted arrays without support

   * for callback shorthands and `this` binding.

   *

   * @private

   * @param {Array} array The array to inspect.

   * @param {Function} [iteratee] The function invoked per iteration.

   * @returns {Array} Returns the new duplicate free array.

   */

  function sortedUniq(array, iteratee) {

    var seen,

        index = -1,

        length = array.length,

        resIndex = -1,

        result = [];

    while (++index < length) {

      var value = array[index],

          computed = iteratee ? iteratee(value, index, array) : value;

        seen = computed;

        result[++resIndex] = value;

      }

    }

    return result;

  }

  /**

   * Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace

   * character of `string`.

   *

   * @private

   * @param {string} string The string to inspect.

   * @returns {number} Returns the index of the first non-whitespace character.

   */

  function trimmedLeftIndex(string) {

    var index = -1,

        length = string.length;

    return index;

  }

  /**

   * Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace

   * character of `string`.

   *

   * @private

   * @param {string} string The string to inspect.

   * @returns {number} Returns the index of the last non-whitespace character.

   */

  function trimmedRightIndex(string) {

    var index = string.length;

    return index;

  }

  /**

   * Used by `_.unescape` to convert HTML entities to characters.

   *

   * @private

   * @param {string} chr The matched character to unescape.

   * @returns {string} Returns the unescaped character.

   */

  function unescapeHtmlChar(chr) {

    return htmlUnescapes[chr];

  }

  /*--------------------------------------------------------------------------*/

  /**

   * Create a new pristine `lodash` function using the given `context` object.

   *

   * @static

   * @memberOf _

   * @category Utility

   * @param {Object} [context=root] The context object.

   * @returns {Function} Returns a new `lodash` function.

   * @example

   *

   * _.mixin({ 'foo': _.constant('foo') });

   *

   * var lodash = _.runInContext();

   * lodash.mixin({ 'bar': lodash.constant('bar') });

   *

   * _.isFunction(_.foo);

   * // => true

   * _.isFunction(_.bar);

   * // => false

   *

   * lodash.isFunction(lodash.foo);

   * // => false

   * lodash.isFunction(lodash.bar);

   * // => true

   *

   * // using `context` to mock `Date#getTime` use in `_.now`

   * var mock = _.runInContext({

   *   'Date': function() {

   *     return { 'getTime': getTimeMock };

   *   }

   * });

   *

   * // or creating a suped-up `defer` in Node.js

   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;

   */

  function runInContext(context) {

    // Avoid issues with some ES3 environments that attempt to use values, named

    // after built-in constructors like `Object`, for the creation of literals.

    // ES5 clears this up by stating that literals must use built-in constructors.

    // See https://es5.github.io/#x11.1.5 for more details.

    context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;

    /** Native constructor references. */

    /** Used for native method references. */

    var arrayProto = Array.prototype,

        errorProto = Error.prototype,

        objectProto = Object.prototype,

        stringProto = String.prototype;

    /** Used to resolve the decompiled source of functions. */

    var fnToString = Function.prototype.toString;

    /** Used to check objects for own properties. */

    var hasOwnProperty = objectProto.hasOwnProperty;

    /** Used to generate unique IDs. */

    var idCounter = 0;

    /**

     * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)

     * of values.

     */

    var objToString = objectProto.toString;

    /** Used to restore the original `_` reference in `_.noConflict`. */

    var oldDash = root._;

    /** Used to detect if a method is native. */

    var reIsNative = RegExp('^' +

      fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')

      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'

    );

    /** Native method references. */

        clearTimeout = context.clearTimeout,

        parseFloat = context.parseFloat,

        pow = Math.pow,

        propertyIsEnumerable = objectProto.propertyIsEnumerable,

        setTimeout = context.setTimeout,

        splice = arrayProto.splice,

    /* Native method references for those with the same name as other `lodash` methods. */

    var nativeCeil = Math.ceil,

        nativeCreate = getNative(Object, 'create'),

        nativeFloor = Math.floor,

        nativeIsArray = getNative(Array, 'isArray'),

        nativeIsFinite = context.isFinite,

        nativeKeys = getNative(Object, 'keys'),

        nativeMax = Math.max,

        nativeMin = Math.min,

        nativeNow = getNative(Date, 'now'),

        nativeParseInt = context.parseInt,

        nativeRandom = Math.random;

    /** Used as references for `-Infinity` and `Infinity`. */

    var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY,

        POSITIVE_INFINITY = Number.POSITIVE_INFINITY;

    /** Used as references for the maximum length and index of an array. */

    var MAX_ARRAY_LENGTH = 4294967295,

        MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,

        HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

    /**

     * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)

     * of an array-like value.

     */

    var MAX_SAFE_INTEGER = 9007199254740991;

    /** Used to store function metadata. */

    var metaMap = WeakMap && new WeakMap;

    /** Used to lookup unminified function names. */

    var realNames = {};

    /** Used to lookup a type array constructors by `toStringTag`. */

    var ctorByTag = {};

    ctorByTag[float32Tag] = context.Float32Array;

    ctorByTag[float64Tag] = context.Float64Array;

    ctorByTag[int8Tag] = context.Int8Array;

    ctorByTag[int16Tag] = context.Int16Array;

    ctorByTag[int32Tag] = context.Int32Array;

    ctorByTag[uint8Tag] = Uint8Array;

    ctorByTag[uint8ClampedTag] = context.Uint8ClampedArray;

    ctorByTag[uint16Tag] = context.Uint16Array;

    ctorByTag[uint32Tag] = context.Uint32Array;

    /** Used to avoid iterating over non-enumerable properties in IE < 9. */

    var nonEnumProps = {};

    nonEnumProps[arrayTag] = nonEnumProps[dateTag] = nonEnumProps[numberTag] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };

    nonEnumProps[boolTag] = nonEnumProps[stringTag] = { 'constructor': true, 'toString': true, 'valueOf': true };

    nonEnumProps[errorTag] = nonEnumProps[funcTag] = nonEnumProps[regexpTag] = { 'constructor': true, 'toString': true };

    nonEnumProps[objectTag] = { 'constructor': true };

    arrayEach(shadowProps, function(key) {

        if (hasOwnProperty.call(nonEnumProps, tag)) {

          var props = nonEnumProps[tag];

          props[key] = hasOwnProperty.call(props, key);

        }

      }

    });

    /*------------------------------------------------------------------------*/

    /**

     * Creates a `lodash` object which wraps `value` to enable implicit chaining.

     * Methods that operate on and return arrays, collections, and functions can

     * be chained together. Methods that retrieve a single value or may return a

     * primitive value will automatically end the chain returning the unwrapped

     * value. Explicit chaining may be enabled using `_.chain`. The execution of

     * chained methods is lazy, that is, execution is deferred until `_#value`

     * is implicitly or explicitly called.

     *

     * Lazy evaluation allows several methods to support shortcut fusion. Shortcut

     * fusion is an optimization strategy which merge iteratee calls; this can help

     * to avoid the creation of intermediate data structures and greatly reduce the

     * number of iteratee executions.

     *

     * Chaining is supported in custom builds as long as the `_#value` method is

     * directly or indirectly included in the build.

     *

     * In addition to lodash methods, wrappers have `Array` and `String` methods.

     *

     * The wrapper `Array` methods are:

     * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`,

     * `splice`, and `unshift`

     *

     * The wrapper `String` methods are:

     * `replace` and `split`

     *

     * The wrapper methods that support shortcut fusion are:

     * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,

     * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,

     * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,

     * and `where`

     *

     * The chainable wrapper methods are:

     * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,

     * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,

     * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defaultsDeep`,

     * `defer`, `delay`, `difference`, `drop`, `dropRight`, `dropRightWhile`,

     * `dropWhile`, `fill`, `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`,

     * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,

     * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,

     * `invoke`, `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`,

     * `matchesProperty`, `memoize`, `merge`, `method`, `methodOf`, `mixin`,

     * `modArgs`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`,

     * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,

     * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `restParam`,

     * `reverse`, `set`, `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`,

     * `sortByOrder`, `splice`, `spread`, `take`, `takeRight`, `takeRightWhile`,

     * `takeWhile`, `tap`, `throttle`, `thru`, `times`, `toArray`, `toPlainObject`,

     * `transform`, `union`, `uniq`, `unshift`, `unzip`, `unzipWith`, `values`,

     * `valuesIn`, `where`, `without`, `wrap`, `xor`, `zip`, `zipObject`, `zipWith`

     *

     * The wrapper methods that are **not** chainable by default are:

     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clone`, `cloneDeep`,

     * `deburr`, `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`,

     * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`,

     * `floor`, `get`, `gt`, `gte`, `has`, `identity`, `includes`, `indexOf`,

     * `inRange`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,

     * `isEmpty`, `isEqual`, `isError`, `isFinite` `isFunction`, `isMatch`,

     * `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`,

     * `isRegExp`, `isString`, `isUndefined`, `isTypedArray`, `join`, `kebabCase`,

     * `last`, `lastIndexOf`, `lt`, `lte`, `max`, `min`, `noConflict`, `noop`,

     * `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`, `reduce`,

     * `reduceRight`, `repeat`, `result`, `round`, `runInContext`, `shift`, `size`,

     * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`,

     * `startsWith`, `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`,

     * `unescape`, `uniqueId`, `value`, and `words`

     *

     * The wrapper method `sample` will return a wrapped value when `n` is provided,

     * otherwise an unwrapped value is returned.

     *

     * @name _

     * @constructor